/*
* Copyright (c) 2005-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:  Effect animation.
*
*/


// INCLUDE FILES
#include <AknsEffectAnim.h>
#include <AknsUtils.h>
#include "AknsAlAnimatorBmp.h"

#include <bitstd.h>
#include <coemain.h>
#include <eikenv.h>

// CONSTANTS

// Alpha blended draw is not currently supported. Enable alpha blended draw by
// uncommenting the definition below
//#define AKNS_EFFECT_ANIM_USE_ALPHA

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

// -----------------------------------------------------------------------------
// CAknsEffectAnim::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CAknsEffectAnim* CAknsEffectAnim::NewL(
    MAknsEffectAnimObserver* aObserver )
    {
    if( !AknsUtils::AvkonHighlightAnimationEnabled() )
        User::Leave( KErrNotSupported );

    if( !AknsUtils::AvkonSkinEnabled() )
        User::Leave( KErrNotSupported );

    if( !aObserver )
        User::Leave( KErrArgument );

    CAknsEffectAnim* self = new(ELeave) CAknsEffectAnim();
    CleanupStack::PushL( self );
    self->ConstructL( aObserver );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::~CAknsEffectAnim
// -----------------------------------------------------------------------------
//
EXPORT_C CAknsEffectAnim::~CAknsEffectAnim()
    {
    delete iAnim; //lint !e1551 No exception thrown
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::ConstructFromSkinL
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::ConstructFromSkinL( const TAknsItemID& aItemID )
    {
    return iAnim->ConstructFromSkinL( aItemID );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::CAknsEffectAnim
// -----------------------------------------------------------------------------
//
CAknsEffectAnim::CAknsEffectAnim()
    {
    // Derived from CBase -> members zeroed
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::ConstructL
// -----------------------------------------------------------------------------
//
void CAknsEffectAnim::ConstructL( MAknsEffectAnimObserver* aObserver )
    {
    iAnim = CAknsAlAnimatorBmp::NewL( aObserver );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Start
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::Start()
    {
    return iAnim->StartAnimation();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Stop
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::Stop()
    {
    return iAnim->StopAnimation();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Pause
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::Pause()
    {
    return iAnim->PauseAnimation();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Continue
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::Continue()
    {
    return iAnim->ContinueAnimation();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::State
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::State()
    {
    return iAnim->State();
    }//lint !e1762 changing to const will change export name mangling

// -----------------------------------------------------------------------------
// CAknsEffectAnim::MinimumSize
// -----------------------------------------------------------------------------
//
EXPORT_C TSize CAknsEffectAnim::MinimumSize() const
    {
    return TSize( KAknsAlAnimMinimumWidth, KAknsAlAnimMinimumHeight );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Size
// -----------------------------------------------------------------------------
//
EXPORT_C TSize CAknsEffectAnim::Size() const
    {
    return iAnim->LayerSize();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::NeedsInputLayer
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::NeedsInputLayer() const
    {
    return iAnim->NeedsInputLayer();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Render
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::Render(
    CFbsBitGc& aGc, const TRect& aGcRect ) const
    {
    return Render( *((CBitmapContext*)&aGc), aGcRect );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Render
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::Render(
    CWindowGc& aGc, const TRect& aGcRect ) const
    {
    return Render( *((CBitmapContext*)&aGc), aGcRect );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::Render
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::Render(
    CBitmapContext& aGc, const TRect& aGcRect ) const
    {
    if( !iAnim->OutputRgb() )
        {
        return EFalse;
        }

#ifdef AKNS_EFFECT_ANIM_USE_ALPHA
    if( iAnim->OutputAlpha() )
        {
        aGc.BitBltMasked( aGcRect.iTl, iAnim->OutputRgb(),
                          TRect( TPoint(0, 0), aGcRect.Size() ),
                          iAnim->OutputAlpha(), EFalse );
        }
    else
#endif // AKNS_EFFECT_ANIM_USE_ALPHA
        {
        aGc.BitBlt( aGcRect.iTl, iAnim->OutputRgb(),
                    TRect( TPoint(0, 0), aGcRect.Size() ) );
        }

    return ETrue;
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::OutputRgb
// -----------------------------------------------------------------------------
//
EXPORT_C const CFbsBitmap* CAknsEffectAnim::OutputRgb() const
    {
    return iAnim->OutputRgb();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::OutputAlpha
// -----------------------------------------------------------------------------
//
EXPORT_C const CFbsBitmap* CAknsEffectAnim::OutputAlpha() const
    {
    return iAnim->OutputAlpha();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::BeginConfigInputLayersL
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknsEffectAnim::BeginConfigInputLayersL(
    const TSize& aNewSize, TBool aAboutToStart )
    {
    iAboutToStart = aAboutToStart;

    // Make sure we have a valid size
    if( aNewSize.iWidth < KAknsAlAnimMinimumWidth ||
        aNewSize.iHeight < KAknsAlAnimMinimumHeight )
        {
        User::Leave( KErrArgument );
        }

    // Determine display mode
    TDisplayMode mode = CCoeEnv::Static()->SystemGc().Device()->DisplayMode();
    // Only two RGB display modes are supported by animation plugins
    if( EColor16M == mode || EColor16MU == mode )
        mode = EColor16MU;
    else // In all other cases use 16-bit colors (565-format assumed)
        mode = EColor64K;

    iAnim->BeginConfigLayersL( aNewSize, mode );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::InputRgbGc
// -----------------------------------------------------------------------------
//
EXPORT_C CFbsBitGc* CAknsEffectAnim::InputRgbGc() const
    {
    return iAnim->InputRgbGc();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::InputAlphaGc
// -----------------------------------------------------------------------------
//
EXPORT_C CFbsBitGc* CAknsEffectAnim::InputAlphaGc() const
    {
    return iAnim->InputAlphaGc();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::EndConfigInputLayersL
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknsEffectAnim::EndConfigInputLayersL()
    {
    iAnim->EndConfigLayersL( (iAboutToStart!= 0 ? ETrue: EFalse) );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::UpdateOutput
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CAknsEffectAnim::UpdateOutput()
    {
    return iAnim->UpdateOutput();
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::SetIdling
// -----------------------------------------------------------------------------
//
EXPORT_C void CAknsEffectAnim::SetIdling( TInt aIntervalMs )
    {
    iAnim->SetIdling( aIntervalMs );
    }

// -----------------------------------------------------------------------------
// CAknsEffectAnim::IsIdling
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CAknsEffectAnim::IsIdling() const
    {
    return iAnim->IsIdling();
    }

// End of file