/*

* Copyright (c) 2007 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 CSAnimMifPlugin class

*

*/

#include <SVGEngineInterfaceImpl.h>

#include "sanimmifplugin.h"

#include "assert.h"

#include "trace.h"

/** MIF header contents. */

class TMifHeader

    {

public:

    TInt32 iUID;

    TInt32 iVersion;

    TInt32 iArrayOffset;

    TInt32 iArrayLength;

    };

typedef TPckgBuf<TMifHeader> TMifHeaderPckg;

/** Icon offset element from MIF file. */

class TIconOffsetElement

    {

public:

    TInt32 iOffset;

    TInt32 iLength;

    };

typedef TPckgBuf<TIconOffsetElement> TIconOffsetElementPckg;

/** Icon header contents. */

class TIconHeader

    {

public:

    TInt32 iUID;

    TInt32 iVersion;

    TInt32 iDataOffset;

    TInt32 iDataLength;

    TInt32 iType;

    TInt32 iDepth;

    TInt32 iAnimated;

    TInt32 iMaskDepth;

    };

typedef TPckgBuf<TIconHeader> TIconHeaderPckg;

/** Type identifier for SVG. */

const TInt KSvgType = 1;

/** Number of array elements one frame occupies (bitmap & mask = 2). */

const TInt KArrElementsPerFrame = 2;

/** Step through icon array with this granularity. */

const TInt KIconArrStep = 2;

// ======== LOCAL FUNCTIONS ========

static TInt TimerCallBack( TAny* aPtr )

    {

    FUNC_LOG;

    static_cast<CSAnimMifPlugin*>( aPtr )->TimerExpired();

    return KErrNone;

    }

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

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

// CSAnimMifPlugin::NewL

//

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

//

CSAnimMifPlugin* CSAnimMifPlugin::NewL( TAny* aConstructionParameters )

    {

    FUNC_LOG;

    CSAnimMifPlugin* self =

        new( ELeave ) CSAnimMifPlugin( aConstructionParameters );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSAnimMifPlugin::~CSAnimMifPlugin

//

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

//

CSAnimMifPlugin::~CSAnimMifPlugin()

    {

    FUNC_LOG;

    delete iDummy;

    delete iTimer;

    iFrames.ResetAndDestroy();

    }

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

// CSAnimMifPlugin::TimerExpired

//

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

//

void CSAnimMifPlugin::TimerExpired()

    {

    FUNC_LOG;

    if ( iCurrentFrame < iFrames.Count() - KArrElementsPerFrame )

        {

        iCurrentFrame += KArrElementsPerFrame; // Each other array element is a mask

        RefreshView();

        }

    else

        {

        iTimer->Cancel();

        CompleteClientRequest( KErrNone );

        }

    }

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

// CSAnimMifPlugin::Load

//

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

//

void CSAnimMifPlugin::Load(

    RFs& aFs,

    const TDesC& aFileName,

    TRequestStatus& aStatus )

    {

    FUNC_LOG;

    INFO_1( "File name: %S", &aFileName );

    iTimer->Cancel();

    iFrames.ResetAndDestroy();

    iCurrentFrame = -1;

    TRAPD( errorCode, LoadL( aFs, aFileName ) );

    ERROR( errorCode, "Failed to load image file" );

    SetClientRequest( aStatus );

    CompleteClientRequest( errorCode );

    }

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

// CSAnimMifPlugin::Start

//

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

//

void CSAnimMifPlugin::Start( TRequestStatus& aStatus )

    {

    FUNC_LOG;

    ASSERT_TRACE( iEngine, SAnimPanic::ENotInitialized );

    ASSERT_TRACE( !( iTimer->IsActive() ), SAnimPanic::EInternalError );

    SetClientRequest( aStatus );

    iCurrentFrame = 0;

    if ( iCurrentFrame < iFrames.Count() - 1 ) // Last one is a mask

        {

        RefreshView();

        iTimer->Start(

            iFrameDelay, iFrameDelay, TCallBack( TimerCallBack, this ) );

        }

    else

        {

        CompleteClientRequest( KErrNone );

        }

    }

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

// CSAnimMifPlugin::Cancel

//

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

//

void CSAnimMifPlugin::Cancel()

    {

    FUNC_LOG;

    CompleteClientRequest( KErrCancel );

    iTimer->Cancel();

    }

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

// CSAnimMifPlugin::BackroundColour

//

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

//

TRgb CSAnimMifPlugin::BackroundColour() const

    {

    FUNC_LOG;

    return KRgbWhite;

    }

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

// CSAnimMifPlugin::UpdateScreen

//

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

//

void CSAnimMifPlugin::UpdateScreen()

    {

    FUNC_LOG;

    }

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

// CSAnimMifPlugin::CSAnimMifPlugin

//

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

//

CSAnimMifPlugin::CSAnimMifPlugin( TAny* aConstructionParameters )

  : CSAnimSvgPluginBase( aConstructionParameters ),

    iCurrentFrame( -1 )

    {

    FUNC_LOG;

    }

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

// CSAnimMifPlugin::ConstructL

//

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

//

void CSAnimMifPlugin::ConstructL()

    {

    FUNC_LOG;

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

    iDummy = new ( ELeave ) CFbsBitmap();

    User::LeaveIfError( iDummy->Create( TSize( 0, 0 ), EGray256 ) );

    }

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

// CSAnimMifPlugin::LoadL

//

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

//

void CSAnimMifPlugin::LoadL( RFs& aFs, const TDesC& aFileName )

    {

    FUNC_LOG;

    delete iEngine;

    iEngine = NULL;

    iEngine = CSvgEngineInterfaceImpl::NewL( iDummy, this, iFontSpec );

    iEngine->SetBackgroundColor( KRgbWhite.Internal() );

    iEngine->SetDRMMode( EFalse );

    RFile file;

    CleanupClosePushL( file );

    User::LeaveIfError( file.Open(

        aFs, aFileName, EFileRead | EFileShareReadersOnly ) );

    TMifHeaderPckg header;

    TInt errorCode = file.Read( header );

    ERROR( errorCode, "CSAnimMifPlugin::LoadL: failed to read file" );

    INFO_2( "CSAnimMifPlugin::LoadL: arr pos %d, arr length %d",

             header().iArrayOffset, header().iArrayLength );

    User::LeaveIfError( errorCode );

    TInt fileSize( 0 );

    errorCode = file.Size( fileSize );

    ERROR( errorCode, "CSAnimMifPlugin::LoadL: failed to read file size" );

    User::LeaveIfError( errorCode );

    if ( header().iArrayOffset < 0 || header().iArrayLength <= 0 ||

         header().iArrayOffset + header().iArrayLength <= 0 ||

         header().iArrayOffset + header().iArrayLength > fileSize )

        {

        User::Leave( KErrCorrupt );

        }

    ReadIconArrayL( file, header().iArrayOffset, header().iArrayLength );

    CleanupStack::PopAndDestroy( &file );

    }

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

// CSAnimMifPlugin::ReadIconArrayL

//

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

//

void CSAnimMifPlugin::ReadIconArrayL(

    RFile& aFile,

    const TInt32 aPosition,

    const TInt32 aLength )

    {

    FUNC_LOG;

    const TInt elementSize = sizeof( TIconOffsetElementPckg ) / 2;

    INFO_1( "Reserving %d bytes", aLength * elementSize );

    HBufC8* iconArray = HBufC8::NewLC( aLength * elementSize );

    TPtr8 iconArrayPtr = iconArray->Des();

    TInt errorCode = aFile.Read( aPosition, iconArrayPtr, aLength * elementSize );

    ERROR( errorCode, "CSAnimMifPlugin::ReadIconArrayL failed to read from file" );

    User::LeaveIfError( errorCode );

    INFO_1( "Read %d bytes", iconArrayPtr.Length() );

    for ( TInt i = 0; i < ( iconArrayPtr.Length() / elementSize ); i += KIconArrStep )

        {

        INFO_1( "Read icon %d", i );

        ReadIconOffsetElementL(

            aFile, iconArrayPtr.MidTPtr( i * elementSize, elementSize ) );

        }

    CleanupStack::PopAndDestroy( iconArray );

    }

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

// CSAnimMifPlugin::ReadIconOffsetElementL

//

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

//

void CSAnimMifPlugin::ReadIconOffsetElementL(

    RFile& aFile,

    const TDesC8& aData )

    {

    FUNC_LOG;

    TIconOffsetElementPckg element;

    element.Copy( aData );

    INFO_2( "Offset %d, length %d", element().iOffset, element().iLength );

    TIconHeaderPckg header;

    TInt errorCode = aFile.Read( element().iOffset, header );

    ERROR( errorCode, "CSAnimMifPlugin::ReadIconOffsetElementL failed to read from file" );

    User::LeaveIfError( errorCode );

    INFO_2( "Data pos %d, data length %d", header().iDataOffset, header().iDataLength );

    INFO_3( "Type %d, depth %d, mask depth %d", header().iType, header().iDepth, header().iMaskDepth );

    if ( header().iType != KSvgType )

        {

        ERROR_1( KErrNotSupported, "Unsupported file type: %d", header().iType );

        User::Leave( KErrNotSupported );

        }

    HBufC8* data = HBufC8::NewLC( header().iDataLength );

    TPtr8 dataPtr = data->Des();

    errorCode = aFile.Read( element().iOffset + header().iDataOffset, dataPtr );

    ERROR( errorCode, "CSAnimMifPlugin::ReadIconOffsetElementL failed to read from file" );

    User::LeaveIfError( errorCode );

    CFbsBitmap* mask = new ( ELeave ) CFbsBitmap();

    CleanupStack::PushL( mask );

    User::LeaveIfError( mask->Create( iSize, EGray256 ) );

    CFbsBitmap* bmp = new ( ELeave ) CFbsBitmap();

    CleanupStack::PushL( bmp );

    User::LeaveIfError(

        bmp->Create( iSize, static_cast<TDisplayMode>( header().iDepth ) ) );

    TInt handle( 0 );

    errorCode = SvgToSymbianErr( iEngine->PrepareDom( dataPtr, handle ) );

    ERROR( errorCode, "Failed to prepare DOM" );

    User::LeaveIfError( errorCode );

    errorCode = SvgToSymbianErr( iEngine->UseDom( handle, bmp, mask ) );

    ERROR( errorCode, "Failed to use DOM" );

    User::LeaveIfError( errorCode );

    iEngine->SetPreserveAspectRatio(

        NULL, ESvgPreserveAspectRatio_XmidYmid, ESvgMeetOrSlice_Meet, ETrue );

    MSvgError* error = NULL;

    iEngine->Start( error );

    errorCode = SvgToSymbianErr( error );

    ERROR( errorCode, "Failed to start engine" );

    User::LeaveIfError( errorCode );

    errorCode = SvgToSymbianErr( iEngine->UseDom( handle, NULL, NULL ) );

    ERROR( errorCode, "Failed to use DOM (empty)" );

    User::LeaveIfError( errorCode );

    iEngine->DeleteDom( handle );

    iFrames.AppendL( bmp );

    CleanupStack::Pop( bmp ); // It's now in the array.

    iFrames.AppendL( mask );

    CleanupStack::Pop( mask ); // It's now in the array.

    CleanupStack::PopAndDestroy( data );

    }

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

// CSAnimMifPlugin::RefreshView

//

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

//

void CSAnimMifPlugin::RefreshView()

    {

    FUNC_LOG;

    ASSERT_TRACE( iCurrentFrame < iFrames.Count() - 1, SAnimPanic::EInternalError );

    iObserver.UpdateScreen(

        *( iFrames[iCurrentFrame] ), *( iFrames[iCurrentFrame + 1] ) );

    }