/*

* 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:   Implementation of CHuiTextureAnimationState.

*

*/

#include <e32base.h>

#include <fbs.h>

#include <bitstd.h>

#include <uiacceltk/HuiUtil.h>

#include "huitextureanimationstate.h"

/**

 * Modifiable bitmap helper class for CHuiTextureAnimationState.

 */

NONSHARABLE_CLASS( CHuiModifiableBitmap ) : public CBase

    {

public:

    /**

     * Two-phased constructor. This creates new bitmap, 

     * this instance owns it until @c ReleaseBitmap is called.

     * @param aSize size of bitmap.

     * @param aMode display mode of bitmap.

     */

    static CHuiModifiableBitmap* NewLC( const TSize& aSize, TDisplayMode aMode );

    /**

     * Two-phased constructor. Use another bitmap and ownership

     * is not taken.

     * @param aBitmap bitmap to be modified.

     */

    static CHuiModifiableBitmap* NewLC( CFbsBitmap& aBitmap );

    /**

     * Destructor.

     */

    ~CHuiModifiableBitmap();

    /**

     * Returns graphics context. Ownership is not passed.

     * @return graphics context.

     */

    CFbsBitGc& Context();    

    /**

     * Releases bitmap and passes ownership to caller.

     * After this has been called, bitmap operations should not

     * be performed through this class.

     * @return bitmap.

     */

    CFbsBitmap* ReleaseBitmap();

    /**

     * Clears the whole bitmap with specified color.

     * @param aColor color to use.

     */

    void Clear( const TRgb& aColor );

    /**

     * Clears area of bitmap with specified color.

     * @param aRect area to fill.

     * @param aColor color to use.

     */

    void Clear( const TRect& aRect, const TRgb& aColor );

    /**

     * Copies area from another bitmap to this one.

     * @param aRect area to copy.

     * @param aBitmap source bitmap.

     */

    void BitBlt( const TRect& aRect, CHuiModifiableBitmap& aBitmap );

    /**

     * Combines source and mask bitmap to this 16MA bitmap.

     * @param aSrc bitmap.

     * @param aSrcMask mask bitmap.

     */

    void Combine( const CFbsBitmap& aSrc, const CFbsBitmap& aSrcMask );

    /**

     * Combines source and mask bitmap to this 16MA bitmap.

     * @para aPos position of bitmap.

     * @param aSrc bitmap.

     * @param aSrcMask mask bitmap.

     */

    void Combine( const TPoint& aPos, const CFbsBitmap& aSrc, const CFbsBitmap& aSrcMask );

    /**

     * Combines gray 256 mask to this gray 256 bitmap. 

     * It's expected that aMask contains only 0 or 255 values.

     * @param aRect rect to combine.

     * @param aMask gray 256 bitmap.

     */

    void CombineMasks( const TRect& aRect, CFbsBitmap* aMask );

    /**

     * Extracts alpha from 16MA source to this EGray256 bitmap.

     * @param aSource source bitmap.

     */

    void ExtractAlpha( CHuiModifiableBitmap& aSource );

    /**

     * Extracts color from 16MA source to this EColor64K/EColor16MU bitmap.

     * @param aSource source bitmap.

     */

    void ExtractColor( CHuiModifiableBitmap& aSource );

private:

    void ConstructL( const TSize& aSize, TDisplayMode aMode );

    void ConstructL( CFbsBitmap& aBitmap );

    template<class Converter>

    static void DoExtractColor( CFbsBitmap* aTarget, CFbsBitmap* aSource );

    struct Convert16MA_16MU

        {    

        inline static TUint32 Convert( TUint32 aPixel );

        };

    struct Convert16MA_64K

        {

        inline static TUint32 Convert( TUint32 aPixel );

        };

private:

    /**

     * Boolean value indicating if iBitmap is owned by this class.

     */

    TBool iOwnBitmap;

    /**

     * Bitmap instance. Ownership depends on value of iOwnBitmap.

     */

    CFbsBitmap* iBitmap;

    /**

     * Bitmap device.

     * Own.

     */

    CFbsBitmapDevice* iDevice;

    /**

     * Graphics context.

     * Own.

     */

    CFbsBitGc* iGc;

    };

CHuiTextureAnimationState* CHuiTextureAnimationState::NewL(

        TInt aTextureGroupId, const TDesC& aImageFile, TInt aFrameCount )

    {

    CHuiTextureAnimationState* self = new (ELeave) CHuiTextureAnimationState;

    CleanupStack::PushL( self );

    self->ConstructL( aTextureGroupId, aImageFile, aFrameCount );

    CleanupStack::Pop( self );

    return self;

    }

CHuiTextureAnimationState::~CHuiTextureAnimationState()

    {

    HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Destroyed"), this );

    delete iFile;

    delete iPrevFrame;

    delete iPrevFrameMask;

    }

TInt CHuiTextureAnimationState::OwnerTextureGroupId() const

    {

    return iTextureGroupId;

    }

TBool CHuiTextureAnimationState::CheckIfCanProduce( 

        const TDesC& aImageFile, TInt aFrameNumber, TInt aFrameCount ) const

    {

    aFrameNumber--;

    TBool ok = ( aFrameCount == iFrameCount ) && 

               ( iFrame <= aFrameNumber ) &&

               !aImageFile.CompareF( *iFile );

    return ok; 

    }

TInt CHuiTextureAnimationState::GetNextFrameNumber() const

    {

    return ( iFrame + 1 );

    }

void CHuiTextureAnimationState::OfferNextFrameInfo( 

        const TFrameInfo& aFrameInfo )

    {

    if ( iFrame == KErrNotFound )

        {

        // First frame defines size of all frames; subsequent frames

        // are deltas to first frame.

        iSize = aFrameInfo.iOverallSizeInPixels;

        }

    iNextSubFrameRect = aFrameInfo.iFrameCoordsInPixels;

    iNextSubFrameBgColor = aFrameInfo.iBackgroundColor;

    if ( aFrameInfo.iFlags & TFrameInfo::ERestoreToPrevious )

        {

        iNextSubFrameDisposalAction = ERestoreToPrevious;

        }

    else if ( aFrameInfo.iFlags & TFrameInfo::ELeaveInPlace )

        {

        // The variable name "'ELeave'InPlace" will cause FALSE positive in CodeScanners "Leave scan"

        iNextSubFrameDisposalAction = ELeaveInPlace;

        }

    else if ( aFrameInfo.iFlags & TFrameInfo::ERestoreToBackground )

        {

        iNextSubFrameDisposalAction = ERestoreToBackgroundColour;

        }

    else

        {

        iNextSubFrameDisposalAction = EUnspecified;

        }

    // If EAlphaChannel flag is on, EGray256 style alpha is available.

    // If ETransparencyPossible flag is on, just EGray2.

    iNextSubFrameHasAlpha = aFrameInfo.iFlags & TFrameInfo::EAlphaChannel;

    }

TSize CHuiTextureAnimationState::OverallSize() const

    {

    return iSize;

    }

void CHuiTextureAnimationState::ProduceNextFrameL(

        CFbsBitmap*& aNewFrame,

        CFbsBitmap*& aNewFrameMask,

        CFbsBitmap* aSubFrame,

        CFbsBitmap* aSubFrameMask )

    {

    HUI_DEBUG2(_L("CHuiTextureAnimationState(%x): Produce next %d"), 

        this, iFrame + 1 );

    HUI_DEBUG4(_L("CHuiTextureAnimationState(%x): pf:%x pfm:%x d:%d"), 

        this, iPrevFrame, iPrevFrameMask, iNextSubFrameDisposalAction );

    aNewFrame = NULL;

    aNewFrameMask = NULL;

    CheckSubFrameL( aSubFrame, aSubFrameMask );

    if ( iFrame == KErrNotFound )

        {

        // Check if previous frames can be reused.

        const TSize frameSize = OverallSize();

        if ( iPrevFrame )

            {

            if ( iPrevFrame->SizeInPixels() != frameSize ||

                 iPrevFrame->DisplayMode() != aSubFrame->DisplayMode() )

                {

                delete iPrevFrame;

                iPrevFrame = NULL;

                }

            }

        if ( iPrevFrameMask && aSubFrameMask )

            {

            if ( iPrevFrameMask->SizeInPixels() != frameSize ||

                 iPrevFrameMask->DisplayMode() != aSubFrameMask->DisplayMode() )

                {

                delete iPrevFrameMask;

                iPrevFrameMask = NULL;

                }

            }

        else

            {

            delete iPrevFrameMask;

            iPrevFrameMask = NULL;

            }

        if ( !iNextSubFrameHasAlpha || !aSubFrameMask )

            {

            HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Quick 1st"), this );

            QuickProduceFirstFrameAndGeneratePreviousL( 

                aNewFrame, aNewFrameMask, 

                aSubFrame, aSubFrameMask );

            }

        else

            {           

            HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Slow 1st"), this );

            ProduceFirstFrameAndGeneratePreviousL( 

                aNewFrame, aNewFrameMask, 

                aSubFrame, aSubFrameMask );

            }

        if ( !aNewFrameMask )

            {

            // So mask was not needed - get rid of previous (if any)

            delete iPrevFrameMask;

            iPrevFrameMask = NULL;

            }

        }

    else

        {

        if ( !iPrevFrame )

            {

            User::Leave( KErrNotSupported );

            }

        if ( !iNextSubFrameHasAlpha || 

             !aSubFrameMask || 

             !iPrevFrameMask )

            {

            HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Quick 2-"), this );

            QuickProduceNextFrameAndUpdatePreviousL(

                aNewFrame, aNewFrameMask,

                aSubFrame, aSubFrameMask );

            }

        else

            {

            HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Slow 2-"), this );

            ProduceNextFrameAndUpdatePreviousL(

                aNewFrame, aNewFrameMask,

                aSubFrame, aSubFrameMask );

            }

        }

    iFrame++; // Go to next frame

    if ( iFrame == ( iFrameCount - 1 ) )

        {

        // Reset back to the beginning

        iFrame = KErrNotFound;

        }

    HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Produce next done"), this );        

    }

void CHuiTextureAnimationState::ProceedWithoutNextFrameL(

        CFbsBitmap* aSubFrame,

        CFbsBitmap* aSubFrameMask )

    {

    // This could be optimized. However, if this method is called,

    // it means that client is anyway using the API in very performance

    // inefficient way, i.e. asking system to load random frames rather

    // than in sequence 0, 1, ..., N.

    CFbsBitmap* frame = NULL;

    CFbsBitmap* frameMask = NULL;

    ProduceNextFrameL( frame, frameMask, aSubFrame, aSubFrameMask );

    delete frame;

    delete frameMask;

    }

CHuiTextureAnimationState::CHuiTextureAnimationState()

    {

    HUI_DEBUG1(_L("CHuiTextureAnimationState(%x): Created"), this );

    }

void CHuiTextureAnimationState::ConstructL( 

        TInt aTextureGroupId, const TDesC& aImageFile, TInt aFrameCount )

    {

    iTextureGroupId = aTextureGroupId;

    iFile = aImageFile.AllocL();

    iFrame = KErrNotFound;

    iFrameCount = aFrameCount;

    }

void CHuiTextureAnimationState::ProduceFirstFrameAndGeneratePreviousL(

        CFbsBitmap*& aNewFrame,

        CFbsBitmap*& aNewFrameMask,

        CFbsBitmap* aSubFrame,

        CFbsBitmap* aSubFrameMask )

    {

    if ( !aSubFrameMask )

        {

        User::Leave( KErrNotSupported );

        }

    const TSize frameSize = OverallSize();

    // Make scratch

    CHuiModifiableBitmap* scratch = 

        CHuiModifiableBitmap::NewLC( frameSize, EColor16MA );

    scratch->Combine( iNextSubFrameRect.iTl, *aSubFrame, *aSubFrameMask );

    // Extract new frame & mask

    CHuiModifiableBitmap* frame = 

        CHuiModifiableBitmap::NewLC( frameSize, aSubFrame->DisplayMode() );

    frame->ExtractColor( *scratch );

    CHuiModifiableBitmap* frameMask = 

        CHuiModifiableBitmap::NewLC( frameSize, EGray256 );

    frameMask->ExtractAlpha( *scratch );

    // Create prev frame & mask

    CHuiModifiableBitmap* prevFrame = 

        iPrevFrame ?

        CHuiModifiableBitmap::NewLC( *iPrevFrame ) :

        CHuiModifiableBitmap::NewLC( frameSize, aSubFrame->DisplayMode() );

    CHuiModifiableBitmap* prevFrameMask = 

        iPrevFrameMask ?

            CHuiModifiableBitmap::NewLC( *iPrevFrameMask ) :

            CHuiModifiableBitmap::NewLC( frameSize, EGray256 );

    prevFrame->Clear( BitmapClearColor() );

    prevFrameMask->Clear( MaskClearColor() );

    switch ( iNextSubFrameDisposalAction )

        {                    

        case ELeaveInPlace:

            prevFrame->BitBlt( iNextSubFrameRect, *frame );

            prevFrameMask->BitBlt( iNextSubFrameRect, *frameMask );

            break;

        case ERestoreToPrevious:

        case EUnspecified:        

        case ERestoreToBackgroundColour:

        default:

            break;

        }

    // Cleanup

    iPrevFrameMask = prevFrameMask->ReleaseBitmap();

    CleanupStack::PopAndDestroy( prevFrameMask );

    iPrevFrame = prevFrame->ReleaseBitmap();

    CleanupStack::PopAndDestroy( prevFrame );

    aNewFrameMask = frameMask->ReleaseBitmap();

    CleanupStack::PopAndDestroy( frameMask );

    aNewFrame = frame->ReleaseBitmap();              

    CleanupStack::PopAndDestroy( frame );

    CleanupStack::PopAndDestroy( scratch ); 

    }

void CHuiTextureAnimationState::ProduceNextFrameAndUpdatePreviousL(

        CFbsBitmap*& aNewFrame,

        CFbsBitmap*& aNewFrameMask,

        CFbsBitmap* aSubFrame,

        CFbsBitmap* aSubFrameMask )

    {

    if ( !aSubFrameMask || !iPrevFrameMask )

        {

        User::Leave( KErrNotSupported );

        }

    const TSize frameSize = OverallSize();

    // Make previous state and blit new subframe on top of that

    CHuiModifiableBitmap* scratch = 

        CHuiModifiableBitmap::NewLC( frameSize, EColor16MA );

    scratch->Combine( *iPrevFrame, *iPrevFrameMask );

    scratch->Context().BitBltMasked(

        iNextSubFrameRect.iTl,

        aSubFrame,

        TRect( aSubFrame->SizeInPixels() ),

        aSubFrameMask,

        ETrue );

    // Extract new frame & mask

    CHuiModifiableBitmap* frame = 

        CHuiModifiableBitmap::NewLC( frameSize, aSubFrame->DisplayMode() );

    frame->ExtractColor( *scratch );

    CHuiModifiableBitmap* frameMask =

        CHuiModifiableBitmap::NewLC( frameSize, EGray256 );

    frameMask->ExtractAlpha( *scratch );

    // Update previous frame & mask

    CHuiModifiableBitmap* prevFrame = 

        CHuiModifiableBitmap::NewLC( *iPrevFrame );

    CHuiModifiableBitmap* prevFrameMask =

        CHuiModifiableBitmap::NewLC( *iPrevFrameMask );

    switch ( iNextSubFrameDisposalAction )

        {                    

        case EUnspecified:

        case ERestoreToBackgroundColour:

            prevFrameMask->Clear( iNextSubFrameRect, MaskClearColor() );

            prevFrame->Clear( iNextSubFrameRect, BitmapClearColor() );

            break;

        case ELeaveInPlace:

            prevFrame->BitBlt( iNextSubFrameRect, *frame );

            prevFrameMask->BitBlt( iNextSubFrameRect, *frameMask );

            break;

        case ERestoreToPrevious:

        default:

            break;

            }

    CleanupStack::PopAndDestroy( prevFrameMask );

    CleanupStack::PopAndDestroy( prevFrame );

    aNewFrame = frame->ReleaseBitmap();

    aNewFrameMask = frameMask->ReleaseBitmap();

    CleanupStack::PopAndDestroy( frameMask );

    CleanupStack::PopAndDestroy( frame );

    CleanupStack::PopAndDestroy( scratch );

    }

void CHuiTextureAnimationState::QuickProduceFirstFrameAndGeneratePreviousL(

        CFbsBitmap*& aNewFrame,

        CFbsBitmap*& aNewFrameMask,

        CFbsBitmap* aSubFrame,

        CFbsBitmap* aSubFrameMask )

    {

    const TSize frameSize = OverallSize();

    const TBool hasAlpha = ( aSubFrameMask != NULL );

    const TBool exactMatch = 

        ( TRect( frameSize ) == iNextSubFrameRect ) &&

        ( aSubFrame->SizeInPixels() == frameSize );

    // Produce new frame & mask

    CHuiModifiableBitmap* frame = 

        CHuiModifiableBitmap::NewLC( frameSize, aSubFrame->DisplayMode() );

    CHuiModifiableBitmap* frameMask = NULL;

    if ( hasAlpha )