/*

* 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 "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:  smiely engine class

*

*/

#include <fbs.h>

#include <AknIconUtils.h>

#include <coeutils.h>

#include <eikedwin.h>

#include "smileybmpobserver.h"

#include "smileydrawer.h"

#include "smileyimagedata.h"

#include "smileyiconrecord.h"

// ======== MEMBER FUNCTIONS ========

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

// CSmileyImageData::CSmileyImageData

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

//

CSmileyBmpObserver::CSmileyBmpObserver( CSmileyAsyncDraw& aAsyncDraw ) : 

    iAsyncDraw( aAsyncDraw )

    {

    }

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

// CSmileyBmpObserver::~CSmileyBmpObserver

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

//

CSmileyBmpObserver::~CSmileyBmpObserver()

    {

    }

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

// CSmileyBmpObserver::SetImageData

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

//

void CSmileyBmpObserver::SetImageData( CSmileyImageData* aImage )

    {

    iImage = aImage;

    }

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

// CSmileyBmpObserver::BitmapChanged

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

//

void CSmileyBmpObserver::BitmapChanged( CFbsBitmap* /*aBitmap*/ )

    {

    if ( iImage )

        {

        if ( !iIsRegisted )

            {

            iAsyncDraw.SmileyDrawer().RegisterAnimChecker( this );

            iIsRegisted = EFalse;

            }

        iIsAnimProgress = ETrue;

        iAsyncDraw.RequestAsyncDraw();

        }

    }

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

// CSmileyBmpObserver::ReplayAnimationL

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

//

void CSmileyBmpObserver::ReplayAnimationL()

    { 

    if ( iImage )

        {

        iAsyncDraw.SmileyDrawer().CreateImageL( iImage );

        }

    }

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

// CSmileyBmpObserver::StopAnimation

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

//

void CSmileyBmpObserver::StopAnimation()

    {

    if ( iImage )

        {

        iImage->DeleteImage();

        iAsyncDraw.SmileyDrawer().RemoveAnimChecker( this );

        }

    }

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

// CSmileyBmpObserver::IsOnProgress

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

//

TBool CSmileyBmpObserver::IsOnProgress() const

    {

    return iIsAnimProgress;

    }

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

// CSmileyBmpObserver::IsOnProgress

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

//

void CSmileyBmpObserver::ResetStatus()

    {

    iIsAnimProgress = EFalse;

    }

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

// CSmileyBmpObserver::IsOnProgress

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

//

void CSmileyBmpObserver::DoOnAnimStoppedL()

    {

    TBool replay( EFalse );   

    for ( TInt i( 0 ); i < iImage->RefArrayCount(); i++ )

        {

        CSmileyIcon* icon( iImage->RefIcon( i ) ); 

        icon->IncreasePlayCount();

        replay = ( replay || !icon->IsPlayFinished() );

        }

    if ( replay )

        {

        iAsyncDraw.AddReplayImage( iImage );

        }

    else

        {

        StopAnimation();

        }

    iAsyncDraw.RequestAsyncDraw( ETrue );

    }

// ======== MEMBER FUNCTIONS ========

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

// CSmileyAsyncDraw::CSmileyAsyncDraw

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

//

CSmileyAsyncDraw::CSmileyAsyncDraw( CSmileyDrawer& aDrawer ) : 

    CActive( EPriorityStandard ), iDrawer( aDrawer )

    {

    CActiveScheduler::Add( this );

    }

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

// CSmileyAsyncDraw::~CSmileyAsyncDraw

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

//

CSmileyAsyncDraw::~CSmileyAsyncDraw()

    {

    Cancel();

    iReplayImageArray.Reset();

    iReplayImageArray.Close();

    }

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

// CSmileyAsyncDraw::StartActive

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

//

void CSmileyAsyncDraw::RequestAsyncDraw( TBool aForce )

    {

    if ( !IsActive() && ( IsRequestIntervalBigEnough() || aForce ) )

        {

        iEverActivated = ETrue;

        iLastRequestTime.HomeTime();

        iStatus = KRequestPending;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();        

        }

    }

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

// CSmileyAsyncDraw::DoCancel

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

//

void CSmileyAsyncDraw::DoCancel()

    {

    }

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

// CSmileyAsyncDraw::RunL

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

//

void CSmileyAsyncDraw::RunL()

    {

    CreateReplayImageL();

    iDrawer.DrawTextView();

    }

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

// CSmileyAsyncDraw::AddReplayImage

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

//

void CSmileyAsyncDraw::AddReplayImage( CSmileyImageData* aImage )

    {

    if ( aImage )

        {

        TBool found( EFalse );

        for ( TInt i( 0 ); i < iReplayImageArray.Count(); i++ )

            {

            if ( iReplayImageArray[i] == aImage )

                {

                found = ETrue;

                break;

                }

            }

        if ( !found )

            {

            aImage->DeleteImage();

            iReplayImageArray.Append( aImage );

            }

        }

    RequestAsyncDraw( ETrue );

    }

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

// CSmileyAsyncDraw::CreateReplayImageL

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

//

void CSmileyAsyncDraw::CreateReplayImageL()

    {

    for ( TInt i( 0 ); i < iReplayImageArray.Count(); i++ )

        {

        iDrawer.CreateImageL( iReplayImageArray[i] );

        }

    iReplayImageArray.Reset();

    }

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

// CSmileyAsyncDraw::IsRequestIntervalBigEnough

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

//

TBool CSmileyAsyncDraw::IsRequestIntervalBigEnough() const

    {

    if ( !iEverActivated )

        {

        return ETrue;

        }

    TTime current;

    current.HomeTime();

    return ( current.MicroSecondsFrom( iLastRequestTime ) >= KDrawIntervalMicroSec );

    }