/*

* 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:   

*

*/

#include "HuiFxEffectParser.h"

#include <stdarg.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include <gmxmlnode.h>

#include <gmxmltext.h>

#include <gmxmlprocessinginstruction.h>

#include <gmxmlcdatasection.h>

#include "HuiFxConstants.h"

#include "HuiFxFilter.h"

#include "HuiFxGroupLayer.h"

#include "HuiFxFilterLayer.h"

#include "HuiFxVisualLayer.h"

#include "HuiFxEffect.h"

#include "HuiFxParameter.h"

#include "HuiFxScalarParameter.h"

#include "HuiFxColorParameter.h"

#include "uiacceltk/HuiVisual.h"  // Class definition

#include "alflogger.h"

#include "huieffectable.h"

#include <stdlib.h>

//#define _HUI_FX_PARSER_LOGGING // Enable this, if you need to debug the xml parsing. otherwise leave this out, because the logging breaks the timing of effects

// Debugging macros

#if !defined(NDEBUG)

#define FAIL(CODE, MSG)         FailL(CODE, MSG)

#define FAIL1(CODE, MSG, P1)    FailL(CODE, MSG, P1)

#else

#define FAIL(CODE, MSG)

#define FAIL1(CODE, MSG, P1)

#endif

CHuiFxEffectParser* CHuiFxEffectParser::NewL(CHuiFxEngine& aEngine, MHuiEffectable* aVisual)

    {

    CHuiFxEffectParser* self = NewLC(aEngine, aVisual);

    CleanupStack::Pop(self);

    return self;

    }

CHuiFxEffectParser* CHuiFxEffectParser::NewLC(CHuiFxEngine& aEngine, MHuiEffectable* aVisual)

    {

    CHuiFxEffectParser* self = new (ELeave) CHuiFxEffectParser( aEngine, aVisual );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CHuiFxEffectParser::ConstructL()

    {

    iParser = CMDXMLParser::NewL( this ) ;

    User::LeaveIfError( iFs.Connect() );

    CActiveScheduler::Add( this );

    }

CHuiFxEffectParser::CHuiFxEffectParser( CHuiFxEngine& aEngine, MHuiEffectable* aVisual ) :

    CActive( EPriorityHigh ),

    iEngine( aEngine ),

    iVisual( aVisual ),

    iParsingEndedObserver( NULL ), iParsingEndedHandle(0)

    {

    __ALFFXLOGSTRING2("CHuiFxEffectParser::CHuiFxEffectParser - this: 0x%x aVisual 0x%x", this, aVisual);

    }

CHuiFxEffectParser::~CHuiFxEffectParser()

    {

    Cancel();

    delete iParser;

    iParser = NULL;

    delete iDoc;

    iDoc = NULL;

    delete iEffect;

    iEffect = NULL;

    iFs.Close();

    __ALFFXLOGSTRING1("CHuiFxEffectParser::~CHuiFxEffectParser - 0x%x ", this);

}

void CHuiFxEffectParser::ParseFileCompleteL()

    {

    TRequestStatus* status = &iStatus;

    TInt err = KErrNone; // We don't get any error from the caller.

    if ( iIsCancelled )

       {

       err = KErrCancel;

       }

    User::RequestComplete( status, err );

    __ALFFXLOGSTRING1("CHuiFxEffectParser::ParseFileCompleteL - 0x%x",this);

    }

void CHuiFxEffectParser::RunL()

    {

    __ALFFXLOGSTRING2("CHuiFxEffectParser::RunL - this 0x%x, status: %d", this, iStatus.Int());

    // RunL will only be called once after the parsing completes

    if ( iStatus.Int() == KErrNone )

        {

        BuildEffectL();

        iEffect->SetEffectFlags( iFlags );

        iFlags = 0;

        // As soon as the visual gets the effect, it kills this effect parser.

        // Therefore the effect must be stored into a temporary variable 

        // and the member of the parser set to null to prevent the fresly released visual

        // from being destroyed immediately.

        // CHuiVisual::SetEffect does dot leave, it just stores the pointer to its own data area,

        // so this is a safe trick, and the boat does not leak.

        if (iParsingEndedObserver)

            {

            iParsingEndedObserver->ParsingEnded(iParsingEndedHandle);

            }

#ifndef HUIFX_EFFECTCACHE_ENABLED

        CHuiFxEffect* tempEffect = iEffect;

#endif

        iEffect = NULL;

        if (iVisual)

            {

            iVisual->EffectSetOpacity(1.0f);

#ifndef HUIFX_EFFECTCACHE_ENABLED

            iVisual->SetEffect( tempEffect );

#endif

            }

        }

    else if ( iStatus.Int() != KErrCancel )

        {

        // some error during parsing - delete possible incomplete effect

        // and set the effect in the visual to NULL as we did not succeed in creating

        // a decent effect

        if (iParsingEndedObserver)

            {

            iParsingEndedObserver->ParsingEnded(iParsingEndedHandle);

            }

        delete iEffect;

        iEffect = NULL;

        if (iVisual)

            {

            iVisual->EffectSetOpacity(1.0f);

            iVisual->EffectSetEffect( NULL );

            }

        }

    else // We got cancelled

        {

        delete iEffect;

        iEffect = NULL;

        }    

    delete this;

    // MUST NOT DO ANYTHING AFTER THE delete this -line!

    }

TInt CHuiFxEffectParser::RunError( TInt /*aError*/ )

    {

    // we signal that we handled the error 

    delete iEffect;

    iEffect = NULL;

    if ( iVisual )

        {

        iVisual->EffectSetEffect( NULL );

        }

    return KErrNone;

    }

void CHuiFxEffectParser::DoCancel()

    {

    // cancel the parsing.

    // 

    iIsCancelled = ETrue;

    iParser->Cancel();

    // parser should now call our ParseFileCompleteL()

    // Unfortunately it will not tell us any error code.

    // Therefore we must remember that we were cancelled.

    // We can only be cancelled when CHuiFxEffectParser is deleted.

    // We do not call iVisual->SetEffect any more in that case 

    // because in that case the parser gets deleted anyway.

    // We don't want to be deleted twice - though setting the parser to NULL after

    // deleting should take care of that anyway.

    // Actually it seems that parser will not necessarily call us,

    // so we must ensure ourselves that we are completed (but only once!)

    // Otherwise then whole system will hang waiting for an event

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrCancel );

    __ALFFXLOGSTRING1("CHuiFxEffectParser::DoCancel - 0x%x",this);

    }

void CHuiFxEffectParser::ParseL( const TDesC& aFile, TRect aExtRect )

    {

    __ALFFXLOGSTRING2("CHuiFxEffectParser::ParseL - 0x%x %S",this, &aFile);

    iIsCancelled = EFalse;

    iExtRect = aExtRect;

    TInt err = iParser->ParseFile( iFs, aFile );

    if ( err != KErrNone )

        {

        // If parsing fails, give up immediately

        iVisual->EffectSetEffect( NULL );

        User::Leave( err );

        }

    iStatus = KRequestPending;

    SetActive();

    // BuildEffectL is called in RunL when parser calls our callback which completes us.

    __ALFFXLOGSTRING("CHuiFxEffectParser::ParseL - activated ");

    }

void CHuiFxEffectParser::Effect( CHuiFxEffect*& aEffect )

    {

    aEffect = iEffect;

    iEffect = NULL;

    }

void CHuiFxEffectParser::SetEffectEndObserver( MAlfGfxEffectObserver* aEffectEndObserver, TInt aHandle )

    {

    iEffectEndObserver = aEffectEndObserver;

    iHandle = aHandle;

    }

void CHuiFxEffectParser::SetParsingEndedObserver( MHuiFxParsingEndedObserver *aObserver, TInt aHandle )

    {

    iParsingEndedObserver = aObserver;

    iParsingEndedHandle = aHandle;

    }

void CHuiFxEffectParser::SetEffectFlags( TInt aFlags )

    {

    iFlags = aFlags;

    }

void CHuiFxEffectParser::BuildEffectL()

    {

    __ALFFXLOGSTRING1("CHuiFxEffectParser::BuildEffectL - 0x%x",this);    

    iEffect = CHuiFxEffect::NewL( iEngine );

    iEffect->SetEffectEndObserver( iEffectEndObserver, iHandle );

    iEffectEndObserver = NULL;

    iHandle = 0;

    iDoc = iParser->DetachXMLDoc();

    User::LeaveIfNull( iDoc );

    CMDXMLElement* root = iDoc->DocumentElement();

    User::LeaveIfNull( root );

    CMDXMLNode* node = root->FirstChild();

    if( node->NodeName().Compare( KLitLayers ) != 0 )

        {

        FAIL(KErrGeneral, _L("Layer list not found"));

        }

    for (node = node->FirstChild(); node; node = node->NextSibling())

        {

        ParseNodeL( node, NULL );

        }

    __ALFFXLOGSTRING("CHuiFxEffectParser::BuildEffectL - complete ");

    }

void CHuiFxEffectParser::ParseNodeL( CMDXMLNode* aNode, CHuiFxLayer* aLayer)

    {

    switch( ResolveNode( aNode ) )

        {

        case ENodeTypeUnknown:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeUnknown");

#endif

            FAIL(KErrGeneral, _L("Unknown node type"));

            break;

            }

        case ENodeTypeGroup:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeGroup");

#endif

            // can't have group layers inside group layer

            if (aLayer && aLayer->Type() == ELayerTypeGroup)

                {

                FAIL(KErrGeneral, _L("Nested group layers not supported"));

                }

            CHuiFxGroupLayer* group = CHuiFxGroupLayer::NewL();

            CleanupStack::PushL( group );

            for (CMDXMLNode* node = aNode->FirstChild(); node; node = node->NextSibling())

                {

                ParseNodeL( node, group );

                }

            iEffect->AddLayerL( group ); // ownership transferred

            CleanupStack::Pop( group );

            break;

            }

        case ENodeTypeFilter:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeFilter");

#endif

            THuiFxFilterType filterType = GetFilterTypeL( aNode );

            CHuiFxFilter* filter = iEngine.CreateFilterL( filterType );

            CleanupStack::PushL( filter );

            CHuiFxFilterLayer* filterLayer = CHuiFxFilterLayer::NewL( filter );

            CleanupStack::Pop( filter );

            CleanupStack::PushL( filterLayer );

            if (aLayer && aLayer->Type() == ELayerTypeGroup)

                {

                CHuiFxGroupLayer* group = reinterpret_cast<CHuiFxGroupLayer*>(aLayer);

                group->AddLayerL( filterLayer ); // ownership transferred

                }

            else

                {

                iEffect->AddLayerL( filterLayer ); // ownership transferred

                }

            CleanupStack::Pop( filterLayer );

            if (filterType == EFilterTypeTransform)

                {

                filterLayer->SetTransformed(ETrue);

                }

            for (CMDXMLNode* node = aNode->FirstChild(); node; node = node->NextSibling())

                {

                ParseNodeL( node, filterLayer );

                }

            break;

            }

        case ENodeTypeVisual:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeVisual");

#endif

            TPtrC16 extBitmap;

            THuiFxVisualSrcType srcType = GetSrcTypeL( aNode, extBitmap );

            CHuiFxVisualLayer* visual = CHuiFxVisualLayer::NewL( *iVisual );

            CleanupStack::PushL( visual );

            visual->SetSourceType( srcType );

            if ( srcType == EVisualSrcBitmap && extBitmap.Length() > 0 )

                {

                visual->SetExtBitmapFileL( extBitmap );

                }

            if (aLayer && aLayer->Type() == ELayerTypeGroup)

                {

                CHuiFxGroupLayer* group = reinterpret_cast<CHuiFxGroupLayer*>(aLayer);

                group->AddLayerL( visual ); // ownership transferred

                }

            else

                {

                iEffect->AddLayerL( visual ); // ownership transferred

                }

            for (CMDXMLNode* node = aNode->FirstChild(); node; node = node->NextSibling())

                {

                ParseNodeL( node, visual );

                }

            CleanupStack::Pop( visual );

            break;

            }

         case ENodeTypeBlending:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeBlending");

#endif

            CMDXMLNode* blendingNode = aNode->FirstChild();

            if( blendingNode->NodeType() != CMDXMLNode::ETextNode )

                {

                FAIL(KErrGeneral, _L("Bad blending mode"));

                }

            TPtrC modePtr( ((CMDXMLText *)blendingNode)->Data() );

            // set replace as default blending mode

            THuiFxBlendingMode blendingMode = EBlendingModeReplace;

            if( modePtr.Compare( KLitReplace ) == 0 )

                {

                blendingMode = EBlendingModeReplace;

                }

            else if( modePtr.Compare( KLitOver ) == 0 )

                {

                blendingMode = EBlendingModeOver;

                }

            else if( modePtr.Compare( KLitMultiply ) == 0 )

                {

                blendingMode = EBlendingModeMultiply;

                }

            else if( modePtr.Compare( KLitAdditive ) == 0 )

                {

                blendingMode = EBlendingModeAdditive;

                }

            else if( modePtr.Compare( KLitDarken ) == 0 )

                {

                blendingMode = EBlendingModeDarken;

                }

            else if( modePtr.Compare( KLitLighten ) == 0 )

                {

                blendingMode = EBlendingModeLighten;

                }

            else

                {

                FAIL(KErrGeneral, _L("Bad blending mode"));

                }

            if (aLayer && aLayer->Type() == ELayerTypeGroup)

                {

                aLayer->SetBlendingMode( blendingMode );

                }

            else

                {

                // TODO: should other layers have a blending mode?

                FAIL(KErrGeneral, _L("Blending mode can only be set for a group layer"));

                }            

            break;

            }

         case  ENodeTypeParam:

            {

#ifdef _HUI_FX_PARSER_LOGGING

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - ENodeTypeParam");

#endif

            ResolveParamL(aNode, aLayer);

            break;

            }

        default:

            __ALFFXLOGSTRING("CHuiFxEffectParser::ParseNodeL - default??");

            break;

        }

    }

CHuiFxEffectParser::TNodeType CHuiFxEffectParser::ResolveNode( CMDXMLNode* aNode )

    {    

    TPtrC nodeName( aNode->NodeName() );

    if( nodeName.Compare( KLitLayerGroup ) == 0 )

        {

        return ENodeTypeGroup;

        }

    else if( nodeName.Compare( KLitFilter ) == 0 )

        {

        return ENodeTypeFilter;

        }

    else if( nodeName.Compare( KLitVisual ) == 0 )

        {

        return ENodeTypeVisual;

        }

    else if( nodeName.Compare( KLitBlending ) == 0 )

        {

        return ENodeTypeBlending;

        }

    else if( nodeName.Compare( KLitParam ) == 0 )

        {

        return ENodeTypeParam;

        }

    else if( nodeName.Compare( KLitStyle ) == 0 )

        {

        return ENodeTypeStyle;

        }

    else if( nodeName.Compare( KLitDuration ) == 0 )

        {

        return ENodeTypeDuration;

        }

    else if( nodeName.Compare( KLitKeyFrame ) == 0 )

        {

        return ENodeTypeKeyFrame;

        }

    else if( nodeName.Compare( KLitMarker ) == 0 )

        {

        return ENodeTypeMarker;

        }

    else if( nodeName.Compare( KLitStart ) == 0 )

        {

        return ENodeTypeStart;

        }

    else if( nodeName.Compare( KLitEnd ) == 0 )

        {

        return ENodeTypeEnd;

        }

    else

        {

        return ENodeTypeUnknown;

        }

    }

// not locale dependent float parser

static TReal32 ParseFloatVal(TPtrC valuePtr)

    {

    HBufC8 *buf = HBufC8::New(valuePtr.Length()+1);

    if (!buf) return 0.0;

    CleanupStack::PushL(buf);

    buf->Des().Copy(valuePtr);

    TUint8 *buf2 = new TUint8[valuePtr.Length()+1];

    if (!buf2) return 0.0;

    int s = valuePtr.Length();

    int i = 0;

    for(;i<s;i++)

        buf2[i] = buf->operator[](i);

    buf2[i] = 0;

    TReal32 v = atof((const char*)buf2);

    delete [] buf2;

    CleanupStack::PopAndDestroy(buf);

    return v;

    }

TReal32 CHuiFxEffectParser::ParseFloatAttributeL(CMDXMLNode* aNode, const TDesC& aName, TBool aMustExist)

    {

    TInt index = ((CMDXMLElement*)aNode)->FindIndex(aName);

    if( index == KErrNotFound )

        {

        if (aMustExist)

            {

            FAIL1(KErrGeneral, _L("Attribute not found: %S"), &aName); // leaves 

            return 0.0f; // never reached. For completeness

            }

        else