/*
* Copyright (c) 2002-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:  Xuikon Bitmap Plugin.
*
*/
#include <AknsUtils.h>
#include <AknsDrawUtils.h>
#include <AknsConstants.h>
#include <barsread.h>
#include <debug.h>

#include "xnnodepluginif.h"
#include "xndomproperty.h"
#include "xnproperty.h"
#include "xncontroladapter.h"

#include "xnanimationadapter.h"

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

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::NewL
// Symbian static 1st phase constructor
// -----------------------------------------------------------------------------
//
CXnAnimationAdapter* CXnAnimationAdapter::NewL(CXnNodePluginIf& aNode)
    {
	CXnAnimationAdapter* self = new( ELeave ) CXnAnimationAdapter( aNode );
    
    CleanupStack::PushL( self );
    self->ConstructL( aNode );
    CleanupStack::Pop();

    return self;	
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::ConstructL(CXnNodePluginIf& aNode)
    {
    CXnControlAdapter::ConstructL( aNode );
    iSkinId = KAknsIIDNone;
    }
    
// -----------------------------------------------------------------------------
// CXnAnimationAdapter::CXnAnimationAdapter
// C++ default constructor
// -----------------------------------------------------------------------------
//
CXnAnimationAdapter::CXnAnimationAdapter(CXnNodePluginIf& aNode) : iNode( aNode )    
    {
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::~CXnAnimationAdapter
// C++ destructor
// -----------------------------------------------------------------------------
//
CXnAnimationAdapter::~CXnAnimationAdapter()
    {
    StopAnimation();
    }


// -----------------------------------------------------------------------------
// CXnAnimationAdapter::Draw
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::Draw(const TRect& aRect) const
    {
    CXnControlAdapter::Draw( aRect );    
    AknsDrawUtils::DrawCachedImage( AknsUtils::SkinInstance(),
               SystemGc(), aRect, iSkinId  );
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::HandlePropertyChangeL
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::DoHandlePropertyChangeL( CXnProperty* aProperty )
    {
    if( aProperty )
        {
        const TDesC8& name( aProperty->Property()->Name( ) );
        
        if( name == XnPropertyNames::style::common::KDisplay )
           {
           const TDesC8& display( aProperty->StringValue() );
 
           if( display == XnPropertyNames::style::common::display::KBlock )
               {
               StartAnimation();
               }    
           else
               {
               StopAnimation();
               }
           }
        }
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::DoEnterPowerSaveModeL
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::DoEnterPowerSaveModeL( TModeEvent /*aEvent*/ )
    {
    iInPowerSaveMode = ETrue;
    StopAnimation();
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::DoExitPowerSaveModeL
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::DoExitPowerSaveModeL( TModeEvent /*aEvent*/ )
    {
    iInPowerSaveMode = EFalse;
    StartAnimation();
    }

// -----------------------------------------------------------------------------
// CXnNewstickerAdapter::MakeVisible()
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::MakeVisible( TBool aVisible )
    {
    TBool visible( IsVisible() ? ETrue : EFalse );
    if ( visible == aVisible ) { return; }
    
    CCoeControl::MakeVisible( aVisible );
    
    if ( aVisible )
        {
        StartAnimation();
        }
    else
        {
        StopAnimation();
        }
    }

// -----------------------------------------------------------------------------
// CXnAnimationAdapter::Update
// -----------------------------------------------------------------------------
//
void CXnAnimationAdapter::Update()
    {
    if ( iPeriodicTimer && iPeriodicTimer->IsActive() )
        {
        switch( iSkinId.iMinor )
            {
            case EAknsMinorGenericQgnHomeRefreshing1:
                {
                iSkinId.Set(KAknsIIDQgnHomeRefreshing2);
                }
                break;
            case EAknsMinorGenericQgnHomeRefreshing2:
                {
                iSkinId.Set(KAknsIIDQgnHomeRefreshing3);
                }
                break;
            case EAknsMinorGenericQgnHomeRefreshing3:
                {
                iSkinId.Set(KAknsIIDQgnHomeRefreshing4);
                }
                break;                
            case EAknsMinorGenericQgnHomeRefreshing4:
                {
                iSkinId.Set(KAknsIIDQgnHomeRefreshing1);
                }
                break;
            default :
                break;
            };
        DrawNow();
        }
    }

// ----------------------------------------------------------------------------
// CXnAnimationAdapter::PeriodicTimerCallBack(TAny* aAny)
// The call back function.
// ----------------------------------------------------------------------------
//
TInt CXnAnimationAdapter::TimerCallBack(TAny* aAny)
    {
    __PRINTS( "CXnAnimationAdapter::TimerCallback, timer runs" );
    CXnAnimationAdapter* self = static_cast<CXnAnimationAdapter*> (aAny);

    // Update widget
    self->Update();

    return KErrNone; // Return value ignored by CPeriodic
    }

// ----------------------------------------------------------------------------
// CXnAnimationAdapter::StartAnimation()
// ----------------------------------------------------------------------------
//
void CXnAnimationAdapter::StartAnimation()
    {
    if ( !iPeriodicTimer && IsVisible() && !iInPowerSaveMode )
        {
       TRAPD(err, iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle) );
       if ( err == KErrNone )
           {
		   const TInt KPeriodicTimerInterval = 100000; // 0.1 sec
           iPeriodicTimer->Start( KPeriodicTimerInterval,
                   KPeriodicTimerInterval, TCallBack( TimerCallBack, this ) );
           iSkinId = KAknsIIDQgnHomeRefreshing1;
           }
        }
    }

// ----------------------------------------------------------------------------
// CXnAnimationAdapter::StopAnimation()
// ----------------------------------------------------------------------------
//
void CXnAnimationAdapter::StopAnimation()
    {
    if ( iPeriodicTimer && iPeriodicTimer->IsActive() )
        {
        iPeriodicTimer->Cancel();
        }
    delete iPeriodicTimer;
    iPeriodicTimer = NULL;
    iSkinId = KAknsIIDNone;
    }

// End of File