/*

* Copyright (c) 2002 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:  Pictograph drawer

*

*/

// INCLUDE FILES

#include "AknPictographAnimator.h"

#include "AknPictographDrawer.h"

#include "AknPictographConstants.h"

#include "AknPictographFactory.h"

#include <gdi.h>

#include <fbs.h>

#include <activitymanager.h>

// CONSTANTS

const TInt KUserActivityTimeout = 15;

const TInt KClientArrayGranularity = 4;

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

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

// CAknPictographAnimator::CAknPictographAnimator

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknPictographAnimator::CAknPictographAnimator() :

    CCoeStatic( KUidAknPictographAnimator ), iClients( KClientArrayGranularity )

	{

	}

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

// CAknPictographAnimator::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknPictographAnimator::ConstructL()

    {

    AknPictographFactory::LoadBitmapsL(iBitmaps, iMasks);

    AknPictographFactory::CreateWhiteBitmapsL(

                                              iWhiteBitmap,

                                              iWhiteBitmapMask,

                                              iWhiteBitmapMaskDevice,

                                              iWhiteBitmapMaskGc

                                              );

    // Needs to be very low priority so that animator cannot prevent any other

    // active objects from running.

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    iUserActivityManager = 

        CUserActivityManager::NewL( CActive::EPriorityStandard );

    // start monitoring user activity

    iUserActivityManager->Start( 

        KUserActivityTimeout,

        TCallBack( InactiveCallBack, this ),

        TCallBack( ActiveCallBack, this ) );

    CCoeEnv* env = CCoeEnv::Static();

    env->AddForegroundObserverL( *this );

    }

CAknPictographAnimator* CAknPictographAnimator::CreateSingletonL()

    {

    CAknPictographAnimator* self = new( ELeave ) CAknPictographAnimator();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAknPictographAnimator::~CAknPictographAnimator()

    {

    CCoeEnv* env = CCoeEnv::Static();

    env->RemoveForegroundObserver( *this );

    delete iTimer; // calls Cancel()

    delete iUserActivityManager;

    iClients.Reset();

    if (iBitmaps)

        {

        iBitmaps->ResetAndDestroy();

        }

    delete iBitmaps;

    if (iMasks)

        {

        iMasks->ResetAndDestroy();

        }

    delete iMasks;

    delete iWhiteBitmapMaskGc;

    delete iWhiteBitmapMaskDevice,

    delete iWhiteBitmapMask;

    delete iWhiteBitmap;

    }

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

// CAknPictographAnimator::AddClientL

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

//

void CAknPictographAnimator::AddClientL( CAknPictographDrawer& aDrawer )

    {

    User::LeaveIfError( iClients.InsertInAddressOrder( &aDrawer ) );

    }

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

// CAknPictographAnimator::RemoveClient

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

//

TInt CAknPictographAnimator::RemoveClient( CAknPictographDrawer& aDrawer )

    {

    TInt index = iClients.FindInAddressOrder( &aDrawer );

    if ( index >= 0 )

        {

        iClients.Remove( index );

        }

    return iClients.Count();

    }

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

// CAknPictographAnimator::TimerCallBack

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

//

TInt CAknPictographAnimator::TimerCallBack( TAny* aParameter )

    {

    static_cast<CAknPictographAnimator*>( aParameter )->AnimationTick();

    return KErrNone;

    }

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

// CAknPictographAnimator::AnimationTick

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

//

void CAknPictographAnimator::AnimationTick()

    {

    iCounter++;

    TInt count = iClients.Count();

    for ( TInt i = 0 ; i < count ; i++ )

        {

        CAknPictographDrawer* drawer = 

            const_cast<CAknPictographDrawer*>( iClients[i] );

        if ( drawer->IsAnimating() )

            {

            drawer->AnimationTick();

            }

        }

    }

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

// CAknPictographAnimator::ActiveCallBack

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

//

TInt CAknPictographAnimator::ActiveCallBack( TAny* aParameter )

    {

    static_cast<CAknPictographAnimator*>( aParameter )->HandleActiveCallBack();

    return KErrNone;

    }

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

// CAknPictographAnimator::InactiveCallBack

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

//

TInt CAknPictographAnimator::InactiveCallBack( TAny* aParameter )

    {

    static_cast<CAknPictographAnimator*>( aParameter )->HandleInactiveCallBack();

    return KErrNone;

    }

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

// CAknPictographAnimator::HandleActiveCallBack

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

//

void CAknPictographAnimator::HandleActiveCallBack()

    {

    if ( iAnimatedClients > 0 && !iTimer->IsActive() )

        {

        iTimer->Start( 

            KAknPictographAnimationDelay,

            KAknPictographAnimationDelay,

            TCallBack( TimerCallBack, this ) );

        }

    }

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

// CAknPictographAnimator::HandleInactiveCallBack

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

//

void CAknPictographAnimator::HandleInactiveCallBack()

    {

    iTimer->Cancel();

    }

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

// CAknPictographAnimator::HandleGainingForeground

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

//

void CAknPictographAnimator::HandleGainingForeground()

    {

    TInt count = iClients.Count();

    for ( TInt i = 0 ; i < count ; i++ )

        {

        iClients[i]->HandleGainingForeground();

        }

    }

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

// CAknPictographAnimator::HandleLosingForeground

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

//

void CAknPictographAnimator::HandleLosingForeground()

    {

    TInt count = iClients.Count();

    for ( TInt i = 0 ; i < count ; i++ )

        {

        iClients[i]->HandleLosingForeground();

        }

    }

//  End of File